Garbage Collection for Strongly-typed Languages Using Run-time Type Reconstruction Garbage Collection for Strongly-typed Languages Using Run-time Type Reconstruction

Garbage collectors perform two functions: live-object detection and dead-object reclamation. In this paper, we present a new technique for live-object detection based on run-time type reconstruction for a strongly-typed, polymorphic language. This scheme uses compile-time type information together with the run-time tree of activation frames to determine the exact type of every object participating in the computation. These reconstructed types are then used to identify and traverse the live heap objects during garbage collection. We describe an implementation of our scheme for the Id parallel programming language compiled for the *T multi-processor architecture. We present simulation studies that compare the performance of type-reconstructing garbage collection with conservative garbage collection and compiler-directed storage reclamation. 1 Introduction Dynamic memory management is an integral component of modern programming languages such as C++, Common Lisp, SML, and Haskell that support the notion of a globally shared heap of objects. It is possible to manage the heap memory explicitly by means of explicit allocation and deallocation calls, but usually it is more convenient to use a separate garbage collector that reclaims storage once it is no longer in use. In such cases, the overall performance of the user program depends heavily on the choice of garbage collection technique and its run-time performance. Abstractly, a garbage collector performs two functions: it distinguishes live objects from those that are garbage (live-object detection), and it reclaims the storage allocated to objects that are garbage (dead-object reclamation). For live-object detection, the garbage collector must be able to distinguish scalar objects from heap objects and determine their sizes (object identiication). Conventional techniques for object identiication 3, 5] operate with a very simple memory model and make little or no use of language and compiler-speciic information. In this paper, we present a new technique for object identiication based on run-time \type reconstruction" for polymorphic languages 1]. Our scheme bridges the gap between the compiler and the garbage collector by using compiler-generated, polymorphic type information and the dynamic call tree of activation frames to compute the exact run-time types of all